#!/usr/bin/env node

/**
 * 智能后端启动脚本
 * 自动检测可用端口，启动服务器，并更新前端代理配置
 */

const { spawn, exec } = require('child_process');
const fs = require('fs');
const path = require('path');
const net = require('net');

// 项目路径
const PROJECT_ROOT = path.dirname(__filename);
const BACKEND_DIR = path.join(PROJECT_ROOT, 'backend');
const ADMIN_DIR = path.join(PROJECT_ROOT, 'admin');
const VITE_CONFIG_PATH = path.join(ADMIN_DIR, 'vite.config.js');

// 端口配置
const PREFERRED_PORTS = [3000, 3001, 3002, 3003, 3004];
const ADMIN_PORT = 5173;

console.log('🚀 CMB250716 智能后端启动器');
console.log('=' .repeat(50));
console.log(`📁 项目根目录: ${PROJECT_ROOT}`);
console.log(`📁 后端目录: ${BACKEND_DIR}`);
console.log(`📁 管理后台目录: ${ADMIN_DIR}`);
console.log('');

/**
 * 检查端口是否可用
 */
function checkPort(port) {
  return new Promise((resolve) => {
    const server = net.createServer();
    
    server.listen(port, () => {
      server.once('close', () => {
        resolve(true); // 端口可用
      });
      server.close();
    });
    
    server.on('error', () => {
      resolve(false); // 端口被占用
    });
  });
}

/**
 * 终止占用指定端口的进程
 */
function killPortProcess(port) {
  return new Promise((resolve) => {
    exec(`lsof -ti:${port}`, (error, stdout) => {
      if (error || !stdout.trim()) {
        resolve(false);
        return;
      }
      
      const pids = stdout.trim().split('\n');
      let killed = 0;
      
      pids.forEach(pid => {
        try {
          process.kill(parseInt(pid), 'SIGTERM');
          killed++;
          console.log(`✅ 已终止占用端口${port}的进程 PID:${pid}`);
        } catch (e) {
          console.log(`⚠️  无法终止进程 PID:${pid}`);
        }
      });
      
      setTimeout(() => resolve(killed > 0), 2000);
    });
  });
}

/**
 * 更新Vite配置文件中的代理端口
 */
function updateViteConfig(backendPort) {
  try {
    if (!fs.existsSync(VITE_CONFIG_PATH)) {
      console.log('⚠️  未找到vite.config.js文件');
      return false;
    }
    
    let config = fs.readFileSync(VITE_CONFIG_PATH, 'utf8');
    
    // 更新代理配置中的端口
    const proxyRegex = /(target:\s*['"]http:\/\/localhost:)\d+(['"])/g;
    const newConfig = config.replace(proxyRegex, `$1${backendPort}$2`);
    
    if (config !== newConfig) {
      fs.writeFileSync(VITE_CONFIG_PATH, newConfig);
      console.log(`✅ 已更新Vite代理配置，后端端口: ${backendPort}`);
      return true;
    }
    
    console.log(`ℹ️  Vite配置已是最新，后端端口: ${backendPort}`);
    return true;
  } catch (error) {
    console.error('❌ 更新Vite配置失败:', error.message);
    return false;
  }
}

/**
 * 创建.env文件
 */
function createEnvFile(port) {
  const envPath = path.join(BACKEND_DIR, '.env');
  const envContent = `# 自动生成的环境配置
PORT=${port}
NODE_ENV=development

# JWT配置
JWT_SECRET=dev_jwt_secret_key_for_local_development
JWT_REFRESH_SECRET=dev_refresh_secret_key_for_local
JWT_EXPIRES_IN=7d
JWT_REFRESH_EXPIRES_IN=30d

# 功能特性开关
IMPORT_V2=true
`;
  
  try {
    fs.writeFileSync(envPath, envContent);
    console.log(`✅ 已创建.env文件，端口: ${port}，包含JWT配置`);
    return true;
  } catch (error) {
    console.error('❌ 创建.env文件失败:', error.message);
    return false;
  }
}

/**
 * 启动后端服务器
 */
function startBackendServer(port) {
  return new Promise((resolve, reject) => {
    console.log(`🚀 启动后端服务器，端口: ${port}`);
    
    // 设置环境变量
    const env = { ...process.env, PORT: port.toString() };
    
    // 启动服务器
    const serverProcess = spawn('npm', ['start'], {
      cwd: BACKEND_DIR,
      env: env,
      stdio: 'inherit'
    });
    
    // 监听进程事件
    serverProcess.on('error', (error) => {
      console.error('❌ 启动服务器失败:', error.message);
      reject(error);
    });
    
    serverProcess.on('exit', (code) => {
      if (code === 0) {
        console.log('✅ 服务器正常退出');
      } else {
        console.log(`⚠️  服务器异常退出，代码: ${code}`);
      }
    });
    
    // 等待一段时间确认启动成功
    setTimeout(() => {
      resolve(serverProcess);
    }, 3000);
  });
}

/**
 * 主启动流程
 */
async function main() {
  try {
    // 1. 检查后端目录
    if (!fs.existsSync(BACKEND_DIR)) {
      throw new Error('未找到backend目录');
    }
    
    if (!fs.existsSync(path.join(BACKEND_DIR, 'package.json'))) {
      throw new Error('backend目录中未找到package.json');
    }
    
    // 2. 清理可能占用的端口
    console.log('🔍 清理端口占用...');
    for (const port of PREFERRED_PORTS) {
      await killPortProcess(port);
    }
    
    // 等待进程完全停止
    await new Promise(resolve => setTimeout(resolve, 3000));
    
    // 3. 寻找可用端口
    console.log('🔍 寻找可用端口...');
    let availablePort = null;
    
    for (const port of PREFERRED_PORTS) {
      const isAvailable = await checkPort(port);
      if (isAvailable) {
        availablePort = port;
        console.log(`✅ 找到可用端口: ${port}`);
        break;
      } else {
        console.log(`❌ 端口${port}被占用`);
      }
    }
    
    if (!availablePort) {
      throw new Error('未找到可用端口');
    }
    
    // 4. 更新配置文件
    console.log('⚙️  更新配置文件...');
    createEnvFile(availablePort);
    updateViteConfig(availablePort);
    
    // 5. 启动服务器
    console.log('');
    console.log('🎯 启动信息:');
    console.log(`   后端服务器: http://localhost:${availablePort}`);
    console.log(`   管理后台: http://localhost:${ADMIN_PORT}`);
    console.log(`   API文档: http://localhost:${availablePort}/api`);
    console.log('');
    console.log('💡 提示: 按 Ctrl+C 停止服务器');
    console.log('=' .repeat(50));
    console.log('');
    
    await startBackendServer(availablePort);
    
  } catch (error) {
    console.error('❌ 启动失败:', error.message);
    process.exit(1);
  }
}

// 优雅关闭处理
process.on('SIGINT', () => {
  console.log('\n🛑 收到停止信号，正在关闭服务器...');
  process.exit(0);
});

process.on('SIGTERM', () => {
  console.log('\n🛑 收到终止信号，正在关闭服务器...');
  process.exit(0);
});

// 启动
main();